Click any tag below to further narrow down your results
Links
Anthropic's Frontier Red Team used Claude, with Theorem Labs, to prove security properties across more than a hundred real open-source libraries in a few weeks. The point is that formal verification, which used to be limited to small codebases or required heavy expert time, may now be practical at scale.
- Formal verification can prove code is free of certain classes of bugs, but has historically been limited to small codebases or costly expert effort.
- Claude was used to prove security properties in over one hundred real-world open-source libraries over a span of a few weeks.
- The work was done in collaboration with Theorem Labs, and the full research is on Anthropic's site.
Bend is a programming language designed to run code as fast as C on CPUs and CUDA on GPUs, while letting you define mathematical laws that the compiler enforces to prevent AI-generated code from breaking your app's core rules. You write laws in a LAWS.bend file, and the compiler demands proof that any code changes satisfy those rules before merging.
- The language compiles to single-core C speeds and parallelizes automatically across thousands of GPU cores without manual threading or locks.
- LAWS.bend lets you declare invariants (like "winning is impossible" or "array_set() never goes out of bounds") that the compiler mathematically verifies, blocking AI mistakes at commit time instead of catching them in production.
- The proof checker runs orders of magnitude faster than existing proof assistants—verifying files in under a second that would take minutes elsewhere—making formal verification practical for everyday development.
Jane Street had long skipped full-on formal methods despite using advanced type systems, but the rise of agent-driven coding cut proof costs and widened access. They’re now forming a team to integrate formal verification into their OCaml toolchain, tweaking the language and tapping their experienced user base while collaborating with external proof ecosystems.
- seL4's formal verification cost 25 person-years for 8,700 lines of C (23 lines of proof per code line, half a person-day per line), illustrating why Jane Street long saw full formal methods as impractical.
- Agentic AI coding flips that math: it lowers the cost of generating proofs and widens access to formal methods, but also produces messy code that creates a new "verification bottleneck."
- Jane Street is building an internal formal-methods team to extend OCaml itself (modular specs, ownership/mutability typing, embedded tactics) rather than switch to tools like Lean, Dafny, or Coq, while still integrating those ecosystems where useful.
- The plan is to use formal verification both to catch bugs in AI-generated code and to feed precise feedback back into training/improving the coding agents.
AWS introduced the Nitro Isolation Engine on its new M9g and M9gd Graviton5 instances and used Isabelle/HOL to prove that it enforces strict VM isolation. They modeled the engine in a subset of Rust (μRust), wrote Separation Logic specifications, and proved functional correctness, memory safety, and noninterference to guarantee confidentiality and integrity.
- AWS deployed a formally verified hypervisor component (Nitro Isolation Engine) into production commercial cloud infrastructure for the first time, on new M9g/M9gd Graviton5 instances.
- They produced 330,000 lines of machine-checked Isabelle/HOL proofs, matching seL4's verification scale, covering functional correctness, memory safety, and noninterference.
- The proof approach modeled the engine in a custom μRust subset (no traits/dynamic dispatch) with Separation Logic specs and a weakest-precondition calculus via their open-source AutoCorrode library.
- Every guest-state-touching operation must pass through this engine, which checks requests against the formal spec to mathematically guarantee VM confidentiality and integrity.
In this Pragmatic Engineer episode, Martin Kleppmann walks through updates in the second edition of Designing Data-Intensive Applications and shares how his LinkedIn experience shaped the book’s core concepts. He breaks down trade-offs in multi-region and cloud architectures, explains why replication still matters more than sharding, and predicts a rise in formal verification and local-first software.
- Second edition of DDIA cuts MapReduce coverage in favor of Spark and Flink, reflecting how the field has moved on
- Manual sharding has become rare thanks to bigger hardware and managed services, making replication the fault-tolerance skill every team now needs
- Kleppmann predicts LLMs will make formal verification mainstream by automating proof generation, shifting the bottleneck to human review
- Architecture decisions like multi-region or multi-cloud are business trade-offs between risk and cost, not universal best practices